/*
 *  web_cam_dev.c - Web Cam device for MTA 2013 class
 */

#include <linux/kernel.h>	/* We're doing kernel work */
#include <linux/module.h>	/* Specifically, a module */
#include <linux/fs.h>
#include <linux/list.h>		/* For holding frames received*/
#include <asm/uaccess.h>	/* for get_user and put_user */
#include <linux/init.h>
#include <linux/debugfs.h>


#include "web_cam_dev.h"
#define SUCCESS 0
#define FAILURE 1
#define DEVICE_NAME "web_cam_dev"
#define BUF_LEN 80
#define AV_NUM_DATA_POINTERS 8
/* 
 * Is the device open right now? Used to prevent
 * concurent access into the same device 
 */
static int Device_Open = 0;

static int frame_width = 0;
static int frame_height = 0;


struct frames_list{
	char * data;
	//uint8_t * frameData[AV_NUM_DATA_POINTERS];
	//int linesize[AV_NUM_DATA_POINTERS];
	struct list_head list;
};

static struct frames_list framesList;

struct mmap_info {
	char *data;	/* the data */
	int reference;       /* how many times it is mmapped */  	
};

static int add_frame_to_list(const char __user * i_Data)
{
	struct frames_list * tmp;

	if (frame_width == 0 || frame_height == 0)
	{
		printk(KERN_INFO "frame_width or frame_height not set! frame rejected!");
		return FAILURE;
	}

	tmp = (struct frames_list *)vmalloc(sizeof(struct frames_list));
	tmp->data = (char *)vmalloc(frame_width * frame_height);
	memset(tmp->data, 0, frame_width * frame_height);
	copy_from_user(tmp->data, i_Data, frame_width * frame_height);
	printk(KERN_INFO "Getting new frame, contents of tmp->data: %s\n", tmp->data);
	/* add the new item 'tmp' to the list of items in framesList */
	list_add(&(tmp->list), &(framesList.list));
	return SUCCESS;
}

// This function should be called after memory has been allocated in user space!
static ssize_t get_latest_frame(char __user * i_Data)
{
	struct list_head * pos, * q;
	struct frames_list * tmp;

	list_for_each_prev_safe(pos, q, &framesList.list){
		tmp = list_entry(pos, struct frames_list, list);
		printk(KERN_INFO "Sending frame back to US, Contents of tmp->data: %s\n", tmp->data);
		copy_to_user(i_Data, tmp->data, frame_width * frame_height);
		printk(KERN_INFO "finished copying frame to user space. Removing it from kernel\n");
		list_del(pos);
		vfree(tmp);			
		break;
	}

	return frame_width * frame_height;
}

/* 
 * This is called whenever a process attempts to open the device file 
 */
static int device_open(struct inode *inode, struct file *file)
{
#ifdef DEBUG
	printk(KERN_INFO "device_open(%p)\n", file);
#endif

	/* 
	 * We don't want to talk to two processes at the same time 
	 */
	if (Device_Open)
		return -EBUSY;

	Device_Open++;

	INIT_LIST_HEAD(&framesList.list);
	try_module_get(THIS_MODULE);
	return SUCCESS;
}

static int device_release(struct inode *inode, struct file *file)
{
#ifdef DEBUG
	printk(KERN_INFO "device_release(%p,%p)\n", inode, file);
#endif

	/* 
	 * We're now ready for our next caller 
	 */
	Device_Open--;

	module_put(THIS_MODULE);
	return SUCCESS;
}

/* 
 * This function is called whenever a process which has already opened the
 * device file attempts to read from it.
 */
static ssize_t device_read(struct file *file,	/* see include/linux/fs.h   */
			   char __user * buffer,	/* buffer to be
							 * filled with data */
			   size_t length,	/* length of the buffer     */
			   loff_t * offset)
{
#ifdef DEBUG
	printk(KERN_INFO "device_read(%p,%p,%d)\n", file, buffer, length);
#endif

	return get_latest_frame(buffer);
}

/* 
 * This function is called when somebody tries to
 * write into our device file. 
 */
static ssize_t
device_write(struct file *file,
	     const char __user * buffer, size_t length, loff_t * offset)
{
#ifdef DEBUG
	printk(KERN_INFO "device_write(%p,%s,%d)", file, buffer, length);
#endif

	add_frame_to_list(buffer);
	return SUCCESS;
}

/* 
 * This function is called whenever a process tries to do an ioctl on our
 * device file. We get two extra parameters (additional to the inode and file
 * structures, which all device functions get): the number of the ioctl called
 * and the parameter given to the ioctl function.
 *
 * If the ioctl is write or read/write (meaning output is returned to the
 * calling process), the ioctl call returns the output of this function.
 *
 */
long device_ioctl(struct file *file,	/* see fs.h */
		 unsigned int ioctl_num,	/* number and param for ioctl */
		 unsigned long ioctl_param)
{
	char *temp;
	int * frameSize;

	/* 
	 * Switch according to the ioctl called 
	 */
	switch (ioctl_num) {
	case IOCTL_SET_FR_SIZE:
		frameSize = (int *)ioctl_param;
		
		get_user(frame_width, frameSize++);
		get_user(frame_height, frameSize);
		printk(KERN_INFO "\nkernal: frame_width: %d", frame_width);
		printk(KERN_INFO "\nkernal: frame_height: %d", frame_height);
		
		break;
	case IOCTL_SET_MSG:
		/* 
		 * Receive a pointer to a message (in user space) and set that
		 * to be the device's message.  Get the parameter given to 
		 * ioctl by the process. 
		 */
		temp = (char *)ioctl_param;

		device_write(file, (char *)ioctl_param, 0, 0);
	
		break;
	case IOCTL_GET_MSG:
		/* 
		 * Give the current message to the calling process - 
		 * the parameter we got is a pointer, fill it. 
		 */
		device_read(file, (char *)ioctl_param, 99, 0);

		break;
	}

	return SUCCESS;
}

/* Module Declarations */

/* 
 * This structure will hold the functions to be called
 * when a process does something to the device we
 * created. Since a pointer to this structure is kept in
 * the devices table, it can't be local to
 * init_module. NULL is for unimplemented functions. 
 */
struct file_operations Fops = {
	.read = device_read,
	.write = device_write,
	.unlocked_ioctl = device_ioctl,
	.open = device_open,
	.release = device_release,	/* a.k.a. close */
};

/* 
 * Initialize the module - Register the character device 
 */
int init_module()
{
	int ret_val;
	/* 
	 * Register the character device (atleast try) 
	 */
	ret_val = register_chrdev(MAJOR_NUM, DEVICE_NAME, &Fops);

	/* 
	 * Negative values signify an error 
	 */
	if (ret_val < 0) {
		printk(KERN_ALERT "%s failed with %d\n",
		       "Sorry, registering the character device ", ret_val);
		return ret_val;
	}

	printk(KERN_INFO "%s The major device number is %d.\n",
	       "Registeration is a success", MAJOR_NUM);
	printk(KERN_INFO "If you want to talk to the device driver,\n");
	printk(KERN_INFO "you'll have to create a device file. \n");
	printk(KERN_INFO "We suggest you use:\n");
	printk(KERN_INFO "mknod %s c %d 0\n", DEVICE_FILE_NAME, MAJOR_NUM);
	printk(KERN_INFO "The device file name is important, because\n");
	printk(KERN_INFO "the ioctl program assumes that's the\n");
	printk(KERN_INFO "file you'll use.\n");

	return 0;
}

/* 
 * Cleanup - unregister the appropriate file from /proc 
 */
void cleanup_module()
{
	/* 
	 * Unregister the device 
	 */
	unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
}
